home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / internet / amitcp3.0b / src.lha / src / amitcp / kern / amiga_netdb.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-08  |  24.1 KB  |  1,006 lines
  1. RCS_ID_C="$Id: amiga_netdb.c,v 3.2 1994/04/06 15:37:29 too Exp $";
  2. /* 
  3.  * amiga_netdb.c --- NetDB Parse Functions
  4.  *
  5.  * Copyright (c) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
  6.  *                    Helsinki University of Technology, Finland.
  7.  *                    All rights reserved.
  8.  *
  9.  * Created      : Tue Apr 27 10:18:58 1993 ppessi
  10.  * Last modified: Wed Apr  6 18:14:49 1994 too
  11.  *
  12.  * $Log: amiga_netdb.c,v $
  13.  * Revision 3.2  1994/04/06  15:37:29  too
  14.  * Added parsing of '@' as match for all private ports (# < 1024)
  15.  * in addaccessent()
  16.  *
  17.  * Revision 3.1  1994/03/26  09:41:13  too
  18.  * Added netdb parsing code for ACCESS control
  19.  *
  20.  * Revision 1.14  1993/07/28  16:00:43  jraja
  21.  * Fixed two inet_aton() calls (return value was misunderstood).
  22.  *
  23.  * Revision 1.13  1993/06/14  15:37:48  jraja
  24.  * Changed file line handling to somewhat better.
  25.  * Added check for too deep recursion of the netdb files.
  26.  *
  27.  * Revision 1.12  1993/06/13  23:39:27  jraja
  28.  * Changed HOST to use Unix compatible format.
  29.  * Added WITH to include other files.
  30.  * '#' as a comment introducer now fully supported.
  31.  * Uses parse function table instead of a switch-case structure.
  32.  * read_netdb() now supports 'prefixes'.
  33.  * read_netdb() now CD's to the AmiTCP:db before opening the file.
  34.  *
  35.  * Revision 1.11  1993/06/04  11:16:15  jraja
  36.  * Fixes for first public release.
  37.  *
  38.  * Revision 1.10  1993/05/29  20:54:12  jraja
  39.  * Changed to use _PATH_NETDB.
  40.  *
  41.  * Revision 1.9  1993/05/17  01:07:47  ppessi
  42.  * Changed RCS version.
  43.  *
  44.  * Revision 1.8  1993/05/16  19:24:03  jraja
  45.  * Changed structure names:
  46.  * NameServerNode => NameserventNode, nameserver => nameservent,
  47.  * DomainNode => DomainentNode, domainname => domainent.
  48.  *
  49.  * Revision 1.7  1993/05/16  00:48:14  jraja
  50.  * Changed init_netdb() to forgive file errors.
  51.  *
  52.  * Revision 1.6  1993/05/16  00:17:32  jraja
  53.  * Changed return values from explicit numbers to RETURN_XXXX.
  54.  * Changed syntax errors to be logged and bypassed.
  55.  * Implemented nameserver and domain parsing.
  56.  *
  57.  * Revision 1.5  93/05/14  11:37:11  11:37:11  ppessi (Pekka Pessi)
  58.  * Cleaned Arexx interface a bit. Private information removed from
  59.  * header files, added to this file.
  60.  * 
  61.  * Revision 1.4  93/05/05  16:10:10  16:10:10  puhuri (Markus Peuhkuri)
  62.  * Fixes for final demo.
  63.  * 
  64.  * Revision 1.3  93/05/04  16:53:28  16:53:28  ppessi (Pekka Pessi)
  65.  * Added net and host entry parsing.
  66.  * 
  67.  * Revision 1.2  93/05/04  12:38:32  12:38:32  jraja (Jarno Tapio Rajahalme)
  68.  * _Minor_ fixes...
  69.  * 
  70.  * Revision 1.1  93/04/28  21:56:49  21:56:49  ppessi (Pekka Pessi)
  71.  * Initial revision
  72.  * 
  73.  */
  74.  
  75. #include <conf.h>
  76.  
  77. #include <sys/param.h>
  78. #include <sys/systm.h>
  79. #include <sys/syslog.h>
  80. #include <sys/socket.h>
  81. #include <sys/malloc.h>
  82. #include <sys/mbuf.h>
  83.  
  84. #include <kern/amiga_includes.h>
  85. #include <kern/amiga_config.h>
  86. #include <kern/amiga_netdb.h>
  87. #include <kern/accesscontrol.h>
  88.  
  89. #include <netinet/in.h>
  90.  
  91. #include <dos/dos.h>
  92. #include <dos/rdargs.h>
  93.  
  94. #if __SASC
  95. #include <proto/dos.h>
  96. #elif __GNUC__
  97. #include <inline/dos.h>
  98. #else
  99. #error Your compiler is not supported in this release.
  100. #endif
  101.  
  102. int inet_aton(register const char *cp, struct in_addr *addr);
  103.  
  104. LONG read_netdb(struct NetDataBase *ndb, UBYTE *fname, const UBYTE** errstrp, struct CSource *res, int prefixindex);
  105.  
  106. /*
  107.  * Global pointer for the NetDataBase
  108.  */
  109. struct NetDataBase *NDB = NULL;
  110.  
  111. /*
  112.  * Default netdatabase name
  113.  */
  114. STRPTR netdbname = _PATH_NETDB;
  115.  
  116. /* 
  117.  * Templates for Arexx commands and DB files
  118.  */
  119. STRPTR NETDBENTRY = 
  120.   "WITH,H=HOST,N=NET,S=SERVICE,P=PROTOCOL,NS=NAMESERVER,DO=DOMAIN,ACC=ACCESS";
  121.  
  122. enum ndbtype { KNDB_WITH, KNDB_HOST, KNDB_NET, KNDB_SERV, KNDB_PROTO, 
  123.            KNDB_DNS, KNDB_DOM, KNDB_ACC };
  124.  
  125. STRPTR NETDBTEMPLATE = 
  126.   "$NAME$/A,$ENTRY$/A,$ALIAS$/M";
  127.  
  128. STRPTR PROTOCOL_TEMPLATE = 
  129.   "$NAME$/A,$NUMBER$/A/N,$ALIAS$/M";
  130.  
  131. enum ndbarg { KNDB_NAME, KNDB_DATA, KNDB_ALIAS };
  132.  
  133. #define NDBARGS 3
  134.  
  135. STRPTR ACCESS_TEMPLATE =
  136.   "$PORT$/A,$HOSTMASK$/A,$ACCESS$/A,LOG/S";
  137.  
  138. enum accarg { KACC_PORT, KACC_HOSTMASK, KACC_ACCESS, KACC_LOG };
  139.  
  140. #define ACCARGS 4
  141.  
  142. STRPTR WITH_TEMPLATE = 
  143.   "$FILE$/A,PREFIX/K";
  144. #define WITHARGS 2
  145. enum witharg { WITH_FILE, WITH_PREFIX };
  146.  
  147. /* prototypes for the netdb parsing functions */
  148.  
  149. LONG addwith(struct NetDataBase *ndb,
  150.          struct RDArgs *rdargs, UBYTE **errstrp);
  151. LONG addhostent(struct NetDataBase *ndb,
  152.         struct RDArgs *rdargs, UBYTE **errstrp);
  153. LONG addnetent(struct NetDataBase *ndb,
  154.            struct RDArgs *rdargs, UBYTE **errstrp);
  155. LONG addservent(struct NetDataBase *ndb,
  156.         struct RDArgs *rdargs, UBYTE **errstrp);
  157. LONG addprotoent(struct NetDataBase *ndb,
  158.          struct RDArgs *rdargs, UBYTE **errstrp);
  159. LONG addnameservent(struct NetDataBase *ndb,
  160.             struct RDArgs *rdargs, UBYTE **errstrp);
  161. LONG adddomainent(struct NetDataBase *ndb,
  162.           struct RDArgs *rdargs, UBYTE **errstrp);
  163. LONG addaccessent(struct NetDataBase *ndb,
  164.           struct RDArgs *rdargs, const UBYTE **errstrp);
  165. LONG addndbent(struct NetDataBase *ndb,
  166.            struct RDArgs *rdargs, UBYTE **errstrp);
  167.  
  168. typedef LONG (*ndb_parse_f)(struct NetDataBase *ndb,
  169.         struct RDArgs *rdargs, UBYTE **errstrp);
  170.  
  171. /* Array of parsing functions. Note that the order is same as in the
  172.  * NETDBENTRY.
  173.  */
  174. ndb_parse_f ndb_parse_funs[] = {
  175.   addwith,
  176.   addhostent,
  177.   addnetent,
  178.   addservent,
  179.   addprotoent,
  180.   addnameservent,
  181.   adddomainent,
  182.   addaccessent
  183. };
  184.  
  185. /*
  186.  * Alloc a NetDataBase
  187.  */
  188. struct NetDataBase *
  189. alloc_netdb(struct NetDataBase *ndb)
  190. {
  191.   if (ndb || 
  192.       (ndb = bsd_malloc(sizeof (*NDB), M_NETDB, M_WAITOK))) {  
  193.     struct MinList *gl;
  194.  
  195.     InitSemaphore(&ndb->ndb_Lock);
  196.     for (gl = (struct MinList *)&ndb->ndb_Hosts;
  197.      gl <= (struct MinList *)&ndb->ndb_Domains;        
  198.      gl++)
  199.       NewList((struct List *)gl);
  200.     
  201.   }
  202.   
  203.   ndb->ndb_AccessCount = 0;
  204.   if ((ndb->ndb_AccessTable =
  205.        bsd_malloc(TMPACTSIZE, M_NETDB, M_WAITOK)) == NULL) {
  206.     bsd_free(ndb, M_NETDB);
  207.     ndb = NULL;
  208.   }
  209.   return ndb;
  210. }
  211.  
  212. /*
  213.  * Free a NetDataBase
  214.  * Caller must have a write lock on NDB
  215.  */
  216. void
  217. free_netdb(struct NetDataBase *ndb)
  218. {
  219.   struct GenentNode *gn;
  220.   struct MinList *gl;
  221.  
  222.   for (gl = (struct MinList *)&ndb->ndb_Hosts;
  223.        gl <= (struct MinList *)&ndb->ndb_Domains;        
  224.        gl++)
  225.     while (gn = (struct GenentNode *)RemHead((struct List *)gl)) 
  226.       bsd_free(gn, M_NETDB);
  227.  
  228.   if (ndb->ndb_AccessTable != NULL) {
  229.     bsd_free(ndb->ndb_AccessTable, M_NETDB);
  230.     ndb->ndb_AccessTable = NULL;
  231.   }
  232.   bsd_free(ndb, M_NETDB);
  233. }
  234.  
  235. #ifdef DEBUG
  236. static char * zap;
  237. static size_t zap_size;
  238. #endif
  239.  
  240. /* 
  241.  * Copy alias list to ato, alias strings and name to cto
  242.  */
  243. static void
  244. aliascpy(UBYTE *cto, UBYTE *name, UBYTE**ato, UBYTE **afrom)
  245. { 
  246. #ifdef DEBUG
  247.   UBYTE *logname = name;
  248. #endif
  249.   do {
  250.     while(*cto++ = *name++);
  251.   } while (afrom && (name = *afrom++) && (*ato++ = cto));
  252.  
  253.   *ato = NULL;
  254.  
  255. #ifdef DEBUG
  256.   if (cto != zap + zap_size) {
  257.     log(LOG_ERR, "%s: mismatch in size %ld != expected %ld\n",
  258.     logname, cto - zap, zap_size);
  259.   } 
  260. #endif
  261. }
  262.  
  263. /*
  264.  * Allocate a netdb node
  265.  *
  266.  * nodesize is the size of the base structure, additional space
  267.  * is allocated for the name and the aliases.
  268.  * alias is NULL terminated array of alias name pointers.
  269.  * Number of aliases is returned via aliasp.
  270.  *
  271.  * size field of the allocated node is set to the total size - size for 
  272.  * the MinNode and the size field itself.
  273.  */
  274. static void *
  275. node_alloc(size_t nodesize, UBYTE *name, UBYTE **alias, int *aliasp)
  276. {
  277.   struct GenentNode *gn;
  278.  
  279.   nodesize += strlen(name) + 1;    /* Add space needed for the name */
  280.  
  281.   *aliasp = 1;
  282.   nodesize += sizeof (char*);    /* Alias list NULL terminator */
  283.  
  284.   /* Calculate the size of the aliases */
  285.   if (alias) {
  286.     while (*alias) {
  287.       (*aliasp)++;
  288.       nodesize += strlen(*alias++) + 1 + sizeof (char*);
  289.     }
  290.   }
  291.   gn = bsd_malloc(nodesize, M_NETDB, M_WAITOK);
  292.   /*
  293.    * set the ent size
  294.    */
  295.   if (gn)
  296.     gn->gn_EntSize = nodesize - sizeof (struct GenentNode);
  297.  
  298. #ifdef DEBUG  
  299.   zap_size = nodesize;
  300.   zap = (char *)gn;
  301. #endif
  302.   return gn;
  303. }
  304.  
  305. /*
  306.  * Parse a service entry.
  307.  */
  308. LONG
  309. addwith(struct NetDataBase *ndb,
  310.     struct RDArgs *rdargs,
  311.     UBYTE **errstrp)
  312. {
  313.   UBYTE result[REPLYBUFLEN + 1];
  314.   struct CSource res;
  315.   LONG retval = RETURN_OK;
  316.   LONG Args[WITHARGS] = { 0 };
  317.   int which;
  318.  
  319.   res.CS_Buffer = result; 
  320.   res.CS_Length = sizeof (result);
  321.   res.CS_CurChr = 0;
  322.  
  323.   if (rdargs = ReadArgs(WITH_TEMPLATE, Args, rdargs)) {
  324.     if (Args[WITH_PREFIX] == 0)    /* no prefix given */
  325.       which = -1;
  326.     else {
  327.       /* match given prefix */
  328.       which = FindArg(NETDBENTRY, (UBYTE *)Args[WITH_PREFIX]);
  329.       if (which < 0) {
  330.     *errstrp = ERR_VALUE;
  331.     retval = RETURN_WARN;
  332.       }
  333.     }
  334.     if (retval == RETURN_OK) {
  335.  
  336.       retval = read_netdb(ndb, (UBYTE *)Args[WITH_FILE], errstrp, &res, 
  337.               which);
  338.  
  339.       if (retval) {
  340.     log(LOG_WARNING, "netdb: WITH file %s: %s", 
  341.         (UBYTE *)Args[WITH_FILE], *errstrp);
  342. #if 0
  343.     if (retval <= RETURN_ERROR)
  344.       retval = RETURN_OK;    /* forgive */
  345. #endif    
  346.       }
  347.     }
  348.     FreeArgs(rdargs);
  349.   } else {
  350.     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
  351.   }
  352.   return retval;
  353. }
  354.  
  355. /*
  356.  * Parse a service entry.
  357.  */
  358. LONG
  359. addservent(struct NetDataBase *ndb,
  360.         struct RDArgs *rdargs,
  361.         UBYTE **errstrp)
  362. {
  363.   LONG retval;
  364.   LONG Args[NDBARGS] = { 0 };
  365.   struct ServentNode *sn;     
  366.   int aliases, plen;
  367.  
  368.   if (rdargs = ReadArgs(NETDBTEMPLATE, Args, rdargs)) {
  369.     /* convert port number */
  370.     UBYTE *s_proto = (UBYTE*)Args[KNDB_DATA];
  371.     if ((plen = StrToLong(s_proto, &Args[KNDB_DATA])) > 0 &&
  372.     s_proto[plen++] == '/') {
  373.       int protonamelen = strlen(s_proto = s_proto + plen) + 1;
  374.       sn = node_alloc(sizeof (*sn) + protonamelen,
  375.               (UBYTE*)Args[KNDB_NAME], 
  376.               (UBYTE **)Args[KNDB_ALIAS], &aliases);
  377.       if (sn) {
  378.     UBYTE **alias = (UBYTE **)(sn+1);
  379.     UBYTE *name = (UBYTE *)(alias + aliases);
  380.  
  381.     sn->sn_Ent.s_port = Args[KNDB_DATA];
  382.     sn->sn_Ent.s_proto = strcpy(name, s_proto);
  383.     sn->sn_Ent.s_name = name + protonamelen;
  384.     sn->sn_Ent.s_aliases = (char **)alias;
  385.  
  386.     /* Copy aliases */
  387.     aliascpy(sn->sn_Ent.s_name, (UBYTE*)Args[KNDB_NAME], 
  388.          alias, (UBYTE **)Args[KNDB_ALIAS]);
  389.     AddTail((struct List*)&ndb->ndb_Services, (struct Node*)sn);
  390.     retval = RETURN_OK;
  391.       } else {
  392.     *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
  393.       }
  394.     } else { 
  395.       *errstrp = ERR_VALUE; retval = RETURN_WARN; 
  396.     } 
  397.     FreeArgs(rdargs);
  398.   } else {
  399.     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
  400.   }
  401.   return retval;
  402. }
  403.  
  404. /*
  405.  * Parse a host entry.
  406.  *
  407.  * NOTE: The host entry has the address in the 'name' and the official name
  408.  * in the 'data'.
  409.  */
  410. LONG
  411. addhostent(struct NetDataBase *ndb,
  412.         struct RDArgs *rdargs,
  413.         UBYTE **errstrp)
  414. {
  415.   LONG retval;
  416.   LONG Args[NDBARGS] = { 0 };
  417.   struct HostentNode *hn;
  418.   struct in_addr addr;
  419.   int aliases;
  420.  
  421.   if (rdargs = ReadArgs(NETDBTEMPLATE, Args, rdargs)) {
  422.     /* convert ip address */
  423.     if (inet_aton((char*)Args[KNDB_NAME], &addr)) {
  424.       hn = node_alloc(sizeof (*hn) + 2*sizeof (&addr) + sizeof (addr),
  425.               (UBYTE*)Args[KNDB_DATA], 
  426.               (UBYTE **)Args[KNDB_ALIAS], &aliases);
  427.       if (hn) {
  428.     struct in_addr **addrtbl = (struct in_addr **)(hn + 1);
  429.     UBYTE **alias = (UBYTE **)((UBYTE*)(addrtbl + 2) + sizeof (addr));
  430.     UBYTE *name = (UBYTE *)(alias + aliases);
  431.  
  432.     hn->hn_Ent.h_addrtype = AF_INET;
  433.     hn->hn_Ent.h_length = sizeof (addr);
  434.     hn->hn_Ent.h_addr_list = (char **)addrtbl;
  435.     hn->hn_Ent.h_name = name;
  436.     hn->hn_Ent.h_aliases = (char **)alias;
  437.  
  438.     /* Make address list */
  439.     addrtbl[0] = (struct in_addr *)(addrtbl + 2);
  440.     addrtbl[1] = NULL;
  441.     bcopy(&addr, addrtbl[0], sizeof (addr));
  442.  
  443.     /* Copy aliases */
  444.     aliascpy(hn->hn_Ent.h_name, (UBYTE*)Args[KNDB_DATA], 
  445.          alias, (UBYTE **)Args[KNDB_ALIAS]);
  446.     AddTail((struct List*)&ndb->ndb_Hosts, (struct Node*)hn);
  447.     retval = RETURN_OK;
  448.       } else {
  449.     *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
  450.       }
  451.     } else { 
  452.       *errstrp = ERR_VALUE; retval = RETURN_WARN; 
  453.     } 
  454.     FreeArgs(rdargs);
  455.   } else {
  456.     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
  457.   }
  458.   return retval;
  459. }
  460.  
  461. /*
  462.  * Parse a net entry.
  463.  */
  464. LONG
  465. addnetent(struct NetDataBase *ndb,
  466.       struct RDArgs *rdargs,
  467.       UBYTE **errstrp)
  468. {
  469.   LONG retval;
  470.   LONG Args[NDBARGS] = { 0 };
  471.   struct NetentNode *nn;
  472.   struct in_addr addr;
  473.   int aliases;
  474.  
  475.   if (rdargs = ReadArgs(NETDBTEMPLATE, Args, rdargs)) {
  476.     /* convert ip address */
  477.     if (inet_aton((char*)Args[KNDB_DATA], &addr)) {
  478.       nn = node_alloc(sizeof (*nn),
  479.               (UBYTE*)Args[KNDB_NAME], 
  480.               (UBYTE **)Args[KNDB_ALIAS], &aliases);
  481.       if (nn) {
  482.     UBYTE **alias = (UBYTE **)(nn + 1);
  483.     UBYTE *name = (UBYTE *)(alias + aliases);
  484.  
  485.     nn->nn_Ent.n_addrtype = AF_INET;
  486.     nn->nn_Ent.n_name = name;
  487.     nn->nn_Ent.n_aliases = (char **)alias;
  488.     bcopy(&addr, &nn->nn_Ent.n_net, sizeof (unsigned long));
  489.  
  490.     /* Copy aliases */
  491.     aliascpy(nn->nn_Ent.n_name, (UBYTE*)Args[KNDB_NAME], 
  492.          alias, (UBYTE **)Args[KNDB_ALIAS]);
  493.     AddTail((struct List*)&ndb->ndb_Networks, (struct Node*)nn);
  494.     retval = RETURN_OK;
  495.       } else {
  496.     *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
  497.       }
  498.     } else { 
  499.       *errstrp = ERR_VALUE; retval = RETURN_WARN;
  500.     } 
  501.     FreeArgs(rdargs);
  502.   } else {
  503.     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
  504.   }
  505.   return retval;
  506. }
  507.  
  508. /*
  509.  * Parse a protocol entry.
  510.  */
  511. LONG
  512. addprotoent(struct NetDataBase *ndb,
  513.         struct RDArgs *rdargs,
  514.         UBYTE **errstrp)
  515. {
  516.   LONG retval;
  517.   LONG Args[NDBARGS] = { 0 };
  518.   struct ProtoentNode *pn;     
  519.   int aliases;
  520.  
  521.   if (rdargs = ReadArgs(PROTOCOL_TEMPLATE, Args, rdargs)) {
  522.     
  523.     if (Args[KNDB_DATA]) {
  524.       pn = node_alloc(sizeof (*pn), (UBYTE*)Args[KNDB_NAME], 
  525.               (UBYTE **)Args[KNDB_ALIAS], &aliases);
  526.       if (pn) {
  527.     UBYTE **alias = (UBYTE **)(pn+1);
  528.     UBYTE *name = (UBYTE *)(alias + aliases);
  529.  
  530.     pn->pn_Ent.p_name = name;
  531.     pn->pn_Ent.p_aliases = (char **)alias;
  532.     pn->pn_Ent.p_proto = *(LONG *)Args[KNDB_DATA];
  533.  
  534.     /* Copy name and aliases */
  535.     aliascpy(name, (UBYTE*)Args[KNDB_NAME], 
  536.          alias, (UBYTE **)Args[KNDB_ALIAS]);
  537.     AddTail((struct List*)&ndb->ndb_Protocols, (struct Node*)pn);
  538.     retval = RETURN_OK;
  539.       } else {
  540.     *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
  541.       }
  542.     } else { 
  543.       *errstrp = ERR_VALUE; retval = RETURN_WARN; 
  544.     } 
  545.     FreeArgs(rdargs);
  546.   } else {
  547.     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
  548.   }
  549.   return retval;
  550. }
  551.  
  552. /*
  553.  * Parse a Name Server entry
  554.  */
  555. LONG
  556. addnameservent(struct NetDataBase *ndb,
  557.            struct RDArgs *rdargs,
  558.            UBYTE **errstrp)
  559. {
  560.   UBYTE Buffer[KEYWORDLEN];
  561.   LONG  BufLen = sizeof (Buffer);
  562.   struct in_addr ns_addr;
  563.   struct NameserventNode *nsn;
  564.  
  565.   if (ReadItem(Buffer, BufLen, &rdargs->RDA_Source) <= 0) {
  566.     *errstrp = ERR_SYNTAX; 
  567.     return RETURN_WARN;
  568.   }
  569.   if (!inet_aton(Buffer, &ns_addr)) {
  570.     *errstrp = ERR_VALUE;
  571.     return RETURN_WARN; 
  572.   }
  573.   if ((nsn = bsd_malloc(sizeof (*nsn), M_NETDB, M_WAITOK)) == NULL) {
  574.     *errstrp = ERR_MEMORY;
  575.     return RETURN_FAIL;
  576.   }
  577.   nsn->nsn_EntSize = sizeof (nsn->nsn_Ent);
  578.   nsn->nsn_Ent.ns_addr = ns_addr;
  579.   
  580.   AddTail((struct List*)&ndb->ndb_NameServers, (struct Node*)nsn);
  581.   return RETURN_OK;
  582. }
  583.  
  584. /*
  585.  * Parse a Domain Name entry
  586.  */
  587. LONG
  588. adddomainent(struct NetDataBase *ndb,
  589.            struct RDArgs *rdargs,
  590.            UBYTE **errstrp)
  591. {
  592.   UBYTE Buffer[REPLYBUFLEN];
  593.   LONG  BufLen = sizeof (Buffer);
  594.   struct DomainentNode *dn;
  595.   short  nodesize;
  596.  
  597.   if (ReadItem(Buffer, BufLen, &rdargs->RDA_Source) <= 0) {
  598.     *errstrp = ERR_SYNTAX; 
  599.     return RETURN_WARN;
  600.   }
  601.   nodesize = sizeof (*dn) + strlen(Buffer) + 1;
  602.   if ((dn = bsd_malloc(nodesize, M_NETDB, M_WAITOK)) == NULL) {
  603.     *errstrp = ERR_MEMORY;
  604.     return RETURN_FAIL;
  605.   }
  606.   dn->dn_EntSize = nodesize - sizeof (struct GenentNode);
  607.   dn->dn_Ent.d_name = (char *)(dn + 1);
  608.   
  609.   strcpy((char *)(dn + 1), Buffer);
  610.  
  611.   AddTail((struct List*)&ndb->ndb_Domains, (struct Node*)dn);
  612.   return RETURN_OK;
  613. }
  614.  
  615. /*
  616.  * Parse a access control entry.. after reading the whole netdatabase
  617.  * access list must be reorganized;
  618.  */
  619. LONG
  620. addaccessent(struct NetDataBase *ndb,
  621.          struct RDArgs *rdargs,
  622.          const UBYTE **errstrp)
  623. {
  624.   LONG retval = RETURN_WARN;
  625.   LONG Args[ACCARGS] = { 0 };
  626.  
  627.   ULONG host, mask;
  628.   UWORD port, flags = ACF_CONTINUE;
  629.  
  630.   if (ndb->ndb_AccessCount >= TMPACTSIZE / sizeof (struct AccessItem)) {
  631.     *errstrp = "Too many access control items\n";
  632.     return retval; /* copy propagation expected */
  633.   }
  634.   
  635.   if ((rdargs = ReadArgs(ACCESS_TEMPLATE, Args, rdargs)) != NULL) {
  636.     
  637.     if (strcmp((char *)Args[KACC_PORT], "*") == 0)
  638.       port = 0;
  639.     else if (strcmp((char *)Args[KACC_PORT], "@") == 0) {
  640.       port = 0; flags |= ACF_PRIVONLY;
  641.     }
  642.     else if (StrToLong((char *)Args[KACC_PORT], (LONG *)&host) > 0
  643.          && host != 0) {
  644.       if (host > 0xffff) {
  645.     *errstrp = "Illegal port value\n";
  646.     goto exit;
  647.       }
  648.       port = host;
  649.     }
  650.     else {
  651.       struct ServentNode * entNode;
  652.  
  653.       if ((entNode =
  654.        findServentNode(ndb, (char *)Args[KACC_PORT], "tcp")) != NULL)
  655.       port = entNode->sn_Ent.s_port;
  656.       else {
  657.     *errstrp = "Illegal port value\n";
  658.     goto exit;
  659.       }
  660.     }
  661.     {
  662.       int zmask = 0xFFFFFFFF;
  663.       int i = 0, ls = 0, dots = 0;
  664.  
  665. #define hm ((char *)Args[KACC_HOSTMASK])
  666.       
  667.       while ((hm[i] >= '0' && hm[i] <= '9') || hm[i] == '.' || hm[i] == '*') {
  668.     if (hm[i] == '.') {
  669.       ls = 0;
  670.       dots++;
  671.     }
  672.     else if (hm[i] == '*') {
  673.       hm[i] = '0';
  674.       ls = 1;
  675.       zmask ^= (0xFF000000 >> 8 * dots);
  676.     }
  677.     i++;
  678.       }
  679.       if (ls == 1)
  680.     while (dots++ < 3)
  681.       zmask ^= (0xFF000000 >> 8 * dots);
  682.  
  683.       if (hm[i] == '/') {
  684.     hm[i++] = '\0';
  685.     if (inet_aton(&hm[i], (struct in_addr *)&mask) == 0) {
  686.       *errstrp = "Illegal mask value\n";
  687.       goto exit;
  688.     }
  689.       }
  690.       else
  691.     mask = 0xffffffff;
  692.  
  693.       mask &= zmask;
  694.       
  695.       if (inet_aton(hm, (struct in_addr *)&host) == 0) {
  696.     *errstrp = "Illegal host value\n";
  697.     goto exit;
  698.       }
  699. #undef hm      
  700.     }
  701.     if (strcmp((char *)Args[KACC_ACCESS], "allow") == 0)
  702.       flags |= ACF_ALLOW;
  703.     else if (strcmp((char *)Args[KACC_ACCESS], "deny") != 0) {
  704.       *errstrp = "Illegal access value\n";
  705.       goto exit;
  706.     }
  707.  
  708.     if (Args[KACC_LOG])
  709.       flags |= ACF_LOG;
  710.     
  711.     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_port = port;
  712.     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_host = host;
  713.     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_mask = mask;
  714.     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_flags = flags;
  715.     ndb->ndb_AccessCount++;
  716.  
  717.     retval = 0;
  718.   exit:
  719.     FreeArgs(rdargs);
  720.   }
  721.   else
  722.     *errstrp = ERR_SYNTAX;
  723.  
  724.   return retval;
  725. }
  726.  
  727. /*
  728.  * Add an entry into NetDB. 
  729.  * Caller must have a write lock on ndb 
  730.  */
  731. LONG 
  732. addndbent(struct NetDataBase *ndb,
  733.       struct RDArgs *rdargs, 
  734.       UBYTE **errstrp)
  735. {
  736.   if (NDB) {
  737.     LONG item;
  738.     enum ndbtype which;
  739.     UBYTE Buffer[KEYWORDLEN];
  740.  
  741.     /* Get entry type */
  742.     item = ReadItem(Buffer, sizeof (Buffer), &rdargs->RDA_Source);
  743.  
  744.     if (item == 0)
  745.       return RETURN_OK;        /* empty line */
  746.     if (item < 0) {
  747.       *errstrp = ERR_SYNTAX;
  748.       return RETURN_WARN;
  749.     }
  750.     if ((which = FindArg(NETDBENTRY, Buffer)) < 0) {
  751.       *errstrp = ERR_UNKNOWN;
  752.       return RETURN_WARN;
  753.     } 
  754.  
  755.     return ndb_parse_funs[which](ndb, rdargs, errstrp);
  756.  
  757.   } else {
  758.     *errstrp = ERR_NONETDB;
  759.     return RETURN_FAIL;
  760.   }
  761. }
  762.  
  763. /* 
  764.  * Read in a NetDataBase file
  765.  */
  766. LONG 
  767. read_netdb(struct NetDataBase *ndb, UBYTE *fname, 
  768.       const UBYTE** errstrp, struct CSource *res, int prefixindex)
  769. {
  770.   LONG warnval = RETURN_OK;
  771.   LONG retval = RETURN_OK, ioerr = 0;
  772.   UBYTE *p, *buf = AllocMem(CONFIGLINELEN, MEMF_PUBLIC);
  773.   struct RDArgs *rdargs;
  774.   BPTR fh;
  775.   short line = 0;
  776.   ndb_parse_f parser;
  777.   BPTR lock, oldcd;
  778.  
  779.   /* Get an exclusive lock on the database.
  780.    * Multiple locks are OK (when this function is called recursively)
  781.    */
  782.   LOCK_W_NDB(ndb);        
  783.   if (ndb->ndb_Lock.ss_NestCount > 10) {
  784.     UNLOCK_NDB(ndb);
  785.     *errstrp = "Too many files included";
  786.     return RETURN_ERROR;
  787.   }
  788.   if (buf) {
  789.  
  790.     /* CD to netdb directory */
  791.     lock = Lock(_PATH_DB, ACCESS_READ);
  792.     if (lock)
  793.       oldcd = CurrentDir(lock);
  794.     
  795.     if (fh = Open(fname, MODE_OLDFILE)) {
  796.       if (rdargs = AllocDosObject(DOS_RDARGS, NULL)) {
  797.     /* initialize CSource of the rdargs */
  798.     rdargs->RDA_Source.CS_Buffer = buf;
  799.     /* initialize rest fields (see dos/rdargs.h) */
  800.     rdargs->RDA_DAList = NULL;
  801.     rdargs->RDA_ExtHelp = NULL;
  802.     rdargs->RDA_Flags = 0;
  803.     
  804.     if (prefixindex < 0)
  805.       parser = addndbent;    /* no prefix */
  806.     else
  807.       parser = ndb_parse_funs[prefixindex];
  808.     
  809.     while (FGets(fh, buf, CONFIGLINELEN - 1)) {
  810.       line++;        /* maintain line number */
  811.       /* pass by white space */
  812.       for (p = buf; *p == ' ' || *p == '\t' || *p == '\r'; p++)
  813.         ;
  814.       rdargs->RDA_Source.CS_CurChr = p - buf;
  815.       if (*p == '#' || *p == ';' || *p == '\n') /* only a comment line */
  816.         continue;
  817.       /* remove comments & calc length */
  818.       for (; *p; p++) { 
  819.         if (*p == '#' || *p == ';') {
  820.           *p++ = '\n';
  821.           *p   = '\0';    /* terminate line */
  822.           break;
  823.         }
  824.       }
  825.       /* ensure that line ends with '\n' (ReadArgs() depends on it) */
  826.       if (*(p - 1) != '\n') {
  827.         *p++ = '\n';
  828.         *p   = '\0';
  829.       }
  830.       rdargs->RDA_Source.CS_Length = p - buf;
  831.       rdargs->RDA_Buffer = NULL;
  832.       rdargs->RDA_BufSiz = 0;
  833.       retval = parser(ndb, rdargs, errstrp);
  834.       if (retval == RETURN_OK)
  835.         continue;
  836.       if (retval != RETURN_WARN) /* severe error */
  837.         break;
  838.       
  839.       /* Log the error */
  840.       log(LOG_NOTICE, "NetDB(%s) line %ld: %s before col %ld\n",
  841.           fname, line, *errstrp, rdargs->RDA_Source.CS_CurChr);
  842.  
  843.       warnval = retval;
  844.     }
  845.     /* Check file error */ 
  846.     ioerr = IoErr();
  847.     
  848.     FreeDosObject(DOS_RDARGS, rdargs);
  849.       }
  850.       Close(fh);
  851.     } else {
  852.       ioerr = IoErr();
  853.     }
  854.     
  855.     if (ioerr) {
  856.       Fault(ioerr, "readnetdb", res->CS_Buffer, res->CS_Length);
  857.       *errstrp = res->CS_Buffer;
  858.       retval = RETURN_ERROR;
  859.     }
  860.     
  861.     /* return old current directory */
  862.     if (lock) {
  863.       CurrentDir(oldcd);
  864.       UnLock(lock);
  865.     }
  866.  
  867.     FreeMem(buf, CONFIGLINELEN);
  868.   } else {
  869.     *errstrp = ERR_MEMORY;
  870.     retval = RETURN_FAIL;
  871.   }
  872.  
  873.   UNLOCK_NDB(ndb);
  874.  
  875.   return retval > warnval? retval: warnval;
  876. }
  877.  
  878. /*
  879.  * Parse the 'ADD' command
  880.  */
  881. LONG
  882. do_netdb(struct CSource *csarg, UBYTE **errstrp, struct CSource *res)
  883. {
  884.   struct RDArgs *rdargs;
  885.   LONG retval;
  886.   
  887.   if (rdargs = AllocDosObject(DOS_RDARGS, NULL)) {
  888.     /* initialize CSource of the rdargs */
  889.     rdargs->RDA_Source = *csarg;
  890.     /* initialize rest fields (see <dos/rdargs.h>) */
  891.     rdargs->RDA_DAList = NULL;
  892.     rdargs->RDA_Buffer = NULL;
  893.     rdargs->RDA_BufSiz = 0;
  894.     rdargs->RDA_ExtHelp = NULL;
  895.     rdargs->RDA_Flags = 0;
  896.  
  897.     LOCK_W_NDB(NDB);
  898.  
  899.     retval = addndbent(NDB, rdargs, errstrp);
  900.  
  901.     UNLOCK_NDB(NDB);
  902.     
  903.     FreeDosObject(DOS_RDARGS, rdargs);
  904.   }
  905.   else 
  906.     retval = RETURN_FAIL;
  907.     
  908.   return retval;
  909. }
  910.  
  911. /*
  912.  * Initialize the Network Data Base
  913.  */
  914. LONG 
  915. init_netdb(void)
  916. {
  917.   UBYTE result[REPLYBUFLEN + 1]; /* for error returns */
  918.   struct CSource res;
  919.   UBYTE *errstr;
  920.   LONG   retval;
  921.  
  922.   res.CS_Buffer = result;      
  923.   res.CS_Length = sizeof (result); 
  924.   res.CS_CurChr = 0;
  925.   
  926.   /* Allocate the NetDataBase */
  927.   if (!(NDB = alloc_netdb(NULL))) {
  928.     return RETURN_FAIL;
  929.   }
  930.  
  931.   /* Read in the default data base file */
  932.   retval = read_netdb(NDB, netdbname, &errstr, &res, -1);
  933.   if (retval)
  934.     log(LOG_WARNING, "init_netdb: file %s: %s", netdbname, errstr);
  935.   else
  936.     setup_accesscontroltable(NDB);
  937.  
  938.   return retval;
  939. }
  940.  
  941.  
  942. void netdb_deinit(void)
  943. {
  944.   /* A Placeholder for possible future deinitializations */
  945. }
  946.   
  947. /*
  948.  * Reset the NetDataBase
  949.  */
  950. LONG reset_netdb(struct CSource *cs,
  951.          UBYTE **errstrp,
  952.          struct CSource *res)
  953. {
  954.   LONG retval;
  955.   struct NetDataBase *newnetdb;
  956.  
  957.   /* Allocate a temporary NetDataBase */
  958.   if (!(newnetdb = alloc_netdb(NULL))) {
  959.     *errstrp = ERR_MEMORY;
  960.     return RETURN_FAIL;
  961.   }
  962.  
  963.   retval = read_netdb(newnetdb, netdbname, errstrp, res, -1);
  964.  
  965.   if (retval == RETURN_OK) {
  966.     /*
  967.      * Success
  968.      */
  969.     struct MinList *gl, *ol;
  970.  
  971.     setup_accesscontroltable(NDB);
  972.  
  973.     /* Now clear the old lists of the NDB */
  974.     LOCK_W_NDB(NDB);
  975.     free_netdb(NDB);
  976.  
  977.     /*
  978.      * Transfer the lists of the new (temporary) database
  979.      * to the NDB.
  980.      */
  981.     for (gl = (struct MinList *)&newnetdb->ndb_Hosts,
  982.      ol = (struct MinList *)&NDB->ndb_Hosts;
  983.      gl <= (struct MinList *)&newnetdb->ndb_Domains;        
  984.      gl++, ol++) {
  985.       if (gl->mlh_Head->mln_Succ) {
  986.     /* There is a non-empty list */
  987.         *ol = *gl;
  988.     ol->mlh_Head->mln_Pred = (struct MinNode*)&ol->mlh_Head;
  989.     ol->mlh_TailPred->mln_Succ = (struct MinNode*)&ol->mlh_Tail;
  990.       }
  991.     }
  992.     NDB->ndb_AccessTable = newnetdb->ndb_AccessTable;
  993.     /*
  994.      * Perhaps ugly...
  995.      */
  996.     newnetdb->ndb_AccessTable = NULL; 
  997.  
  998.     UNLOCK_NDB(NDB);
  999.   } else {
  1000.     free_netdb(newnetdb);
  1001.   }
  1002.  
  1003.   bsd_free(newnetdb, M_NETDB);    /* free the temporary database */
  1004.   return retval;
  1005. }
  1006.